const express = require('express');
const router = express.Router();
const jwt = require('jsonwebtoken');
const bcrypt = require('bcryptjs');
const User = require('../models/User');

// JWT密钥
const JWT_SECRET = process.env.JWT_SECRET || 'your-secret-key';

// 注册新用户 (仅限管理员)
router.post('/register', async (req, res) => {
  try {
    const { username, email, password, role } = req.body;
    
    // 验证必填字段
    if (!username || !email || !password) {
      return res.status(400).json({ message: '用户名、邮箱和密码为必填项' });
    }
    
    // 检查用户名是否已存在
    const existingUser = await User.findOne({ $or: [{ username }, { email }] });
    if (existingUser) {
      return res.status(400).json({ message: '用户名或邮箱已存在' });
    }
    
    // 创建新用户
    const newUser = new User({
      username,
      email,
      password,
      role: role || 'viewer' // 默认为查看者角色
    });
    
    await newUser.save();
    
    res.status(201).json({ 
      message: '用户注册成功',
      user: {
        id: newUser._id,
        username: newUser.username,
        email: newUser.email,
        role: newUser.role
      }
    });
  } catch (error) {
    console.error('用户注册失败:', error);
    res.status(500).json({ message: '服务器错误', error: error.message });
  }
});

// 用户登录
router.post('/login', async (req, res) => {
  try {
    const { username, password } = req.body;
    
    // 验证必填字段
    if (!username || !password) {
      return res.status(400).json({ message: '用户名和密码为必填项' });
    }
    
    // 查找用户
    const user = await User.findOne({ 
      $or: [{ username }, { email: username }],
      active: true
    });
    
    if (!user) {
      return res.status(401).json({ message: '用户名或密码不正确' });
    }
    
    // 验证密码
    const isMatch = await user.matchPassword(password);
    if (!isMatch) {
      return res.status(401).json({ message: '用户名或密码不正确' });
    }
    
    // 更新最后登录时间
    user.lastLogin = new Date();
    await user.save();
    
    // 创建JWT令牌
    const token = jwt.sign(
      { id: user._id, username: user.username, role: user.role },
      JWT_SECRET,
      { expiresIn: '24h' }
    );
    
    res.json({
      message: '登录成功',
      token,
      user: {
        id: user._id,
        username: user.username,
        email: user.email,
        role: user.role
      }
    });
  } catch (error) {
    console.error('用户登录失败:', error);
    res.status(500).json({ message: '服务器错误', error: error.message });
  }
});

// 获取当前用户信息
router.get('/me', async (req, res) => {
  try {
    // 从请求头中获取Token
    const token = req.headers.authorization?.split(' ')[1];
    
    if (!token) {
      return res.status(401).json({ message: '未提供认证令牌' });
    }
    
    // 验证Token
    const decoded = jwt.verify(token, JWT_SECRET);
    
    // 查找用户
    const user = await User.findById(decoded.id).select('-password');
    
    if (!user || !user.active) {
      return res.status(401).json({ message: '用户不存在或已禁用' });
    }
    
    res.json(user);
  } catch (error) {
    if (error.name === 'JsonWebTokenError' || error.name === 'TokenExpiredError') {
      return res.status(401).json({ message: '无效的认证令牌' });
    }
    console.error('获取用户信息失败:', error);
    res.status(500).json({ message: '服务器错误', error: error.message });
  }
});

// 更新用户信息
router.put('/me', async (req, res) => {
  try {
    // 从请求头中获取Token
    const token = req.headers.authorization?.split(' ')[1];
    
    if (!token) {
      return res.status(401).json({ message: '未提供认证令牌' });
    }
    
    // 验证Token
    const decoded = jwt.verify(token, JWT_SECRET);
    
    // 获取可更新的字段
    const { email, password, currentPassword } = req.body;
    
    // 查找用户
    const user = await User.findById(decoded.id);
    
    if (!user || !user.active) {
      return res.status(401).json({ message: '用户不存在或已禁用' });
    }
    
    // 如果要更新密码，需要验证当前密码
    if (password) {
      if (!currentPassword) {
        return res.status(400).json({ message: '需要提供当前密码' });
      }
      
      const isMatch = await user.matchPassword(currentPassword);
      if (!isMatch) {
        return res.status(401).json({ message: '当前密码不正确' });
      }
      
      user.password = password;
    }
    
    // 更新邮箱
    if (email) {
      user.email = email;
    }
    
    // 保存更新
    await user.save();
    
    res.json({
      message: '用户信息更新成功',
      user: {
        id: user._id,
        username: user.username,
        email: user.email,
        role: user.role
      }
    });
  } catch (error) {
    if (error.name === 'JsonWebTokenError' || error.name === 'TokenExpiredError') {
      return res.status(401).json({ message: '无效的认证令牌' });
    }
    console.error('更新用户信息失败:', error);
    res.status(500).json({ message: '服务器错误', error: error.message });
  }
});

// 管理员获取所有用户列表
router.get('/users', async (req, res) => {
  try {
    // 从请求头中获取Token
    const token = req.headers.authorization?.split(' ')[1];
    
    if (!token) {
      return res.status(401).json({ message: '未提供认证令牌' });
    }
    
    // 验证Token和权限
    const decoded = jwt.verify(token, JWT_SECRET);
    
    // 查找用户并检查权限
    const user = await User.findById(decoded.id);
    
    if (!user || user.role !== 'admin') {
      return res.status(403).json({ message: '没有权限执行此操作' });
    }
    
    // 获取所有用户
    const users = await User.find().select('-password').sort({ username: 1 });
    
    res.json(users);
  } catch (error) {
    if (error.name === 'JsonWebTokenError' || error.name === 'TokenExpiredError') {
      return res.status(401).json({ message: '无效的认证令牌' });
    }
    console.error('获取用户列表失败:', error);
    res.status(500).json({ message: '服务器错误', error: error.message });
  }
});

// 管理员更新用户状态
router.patch('/users/:id/status', async (req, res) => {
  try {
    // 从请求头中获取Token
    const token = req.headers.authorization?.split(' ')[1];
    
    if (!token) {
      return res.status(401).json({ message: '未提供认证令牌' });
    }
    
    // 验证Token和权限
    const decoded = jwt.verify(token, JWT_SECRET);
    
    // 查找用户并检查权限
    const adminUser = await User.findById(decoded.id);
    
    if (!adminUser || adminUser.role !== 'admin') {
      return res.status(403).json({ message: '没有权限执行此操作' });
    }
    
    // 获取目标用户和状态
    const { active } = req.body;
    
    if (active === undefined) {
      return res.status(400).json({ message: '状态参数缺失' });
    }
    
    // 防止管理员禁用自己的账户
    if (req.params.id === decoded.id.toString() && active === false) {
      return res.status(400).json({ message: '不能禁用自己的账户' });
    }
    
    // 更新用户状态
    const updatedUser = await User.findByIdAndUpdate(
      req.params.id,
      { active },
      { new: true }
    ).select('-password');
    
    if (!updatedUser) {
      return res.status(404).json({ message: '用户不存在' });
    }
    
    res.json({ 
      message: `用户状态已更新为 ${active ? '启用' : '禁用'}`,
      user: updatedUser
    });
  } catch (error) {
    if (error.name === 'JsonWebTokenError' || error.name === 'TokenExpiredError') {
      return res.status(401).json({ message: '无效的认证令牌' });
    }
    console.error('更新用户状态失败:', error);
    res.status(500).json({ message: '服务器错误', error: error.message });
  }
});

module.exports = router; 